Programando IA com R

Portfólio

Conceitos de variáveis

Vetor

Toda variável no R é um vetor, um vetor pode visto como um conjunto de valores linear e homogêneo.

Para atribuir um valor à uma variável, utilizamos a seta <- indicando para onde estamos direcionando o valor.

É importante saber também, que para criar um vetor com valores, podemos utilizar a função c() que combina os valores em um vetor

Sendo assim, abaixo estamos criando a variável vetor e atribuindo o valor 1 5 4

vetor <- c(1, 5, 4)

vetor

Tipos de valores

Numéricos e Caracteres

No R tempos o conceito de tipos, onde cada valor tem um tipo específico, lembra das aulas de matemática sobre inteiros, decimais, etc?

Para verificar o tipo interpretado pelo R de um valor, podemos utilizar a função class(valor), onde valor é igual ao valor que você quer verificar.

class(5)
class("Olá mundo")

Reconhecendo tipos de variáveis

Veja que o R reconheceu o valor 5 como númerico e o texto “Olá mundo” como um conjunto de caracteres.

Isto também se aplica a variáveis, veja só:

variavel_numerica <- c(1,5,4,7)
variavel_caracteres <- c("Olá mundo")

class(variavel_numerica)
class(variavel_caracteres)

Também podemos usar as funções disponíveis em “is” para verificar os tipos, essa verificação retorna um tipo lógico para nós

variavel <- "5"
is.numeric(variavel)
is.character(variavel)

Lógicos

No R, também é possível criar tipos lógicos (verdadeiro ou falso)

logicos <- c(TRUE, FALSE, TRUE)
logicos2 <- c(T, F, T)

logicos
logicos2

class(logicos)

Veja que é possível abreviar as declarações.

Inteiros Explicitos

Você deve ter percebido que no caso do tipo numérico, o tipo não foi declarado explicitamente como inteiro, para fazer isso veja o próximo trecho:

inteiros <- c(1L, 2L, 3L)

inteiros
class(inteiros)

Gerando sequências

Gerar sequências no R é uma coisa muito fácil e divertida! Temos algumas formas para fazer isso:

#Gerando números de 1 a 10
1:10

#Gerando números de 10 a 1
10:1

#Gerando números de 100 a 120

seq(100, 120)

#Gerando 10 números a partir de 100

seq(100, length.out = 10)

#Gerando números de 10 a 20 de 2 em 2

seq.int(from = 10, to = 20, by = 2)

#Gerando 20 números

seq_len(20)

#Gerando um vetor do mesmo tamanho que o vetor passado

seq_along(c(70, 2))

#Repetindo o número 4 5 vezes

rep(4, times = 5)

NA, NaN, Inf, -Inf e NULL

Os tipos especiais são valores que possuem uma característica bem específica.

NA = Não disponível (Not Available) NaN = Não númerico (Not A Number) Inf = Infinito -Inf = -Infinito NULL = Vazio

Perceba que NA possui um tipo, mas NULL não, NULL representa o nada no caso do R e de diversas linguagens de programação.

Um detalhe é que não é possível colocar NULL em um vetor, ou seja, caso criemos um vetor com NULL, o R remove ele automáticamente

valor.na <- NA
valor.null <- NULL
valor.infinito <- Inf;
valor.menos.infinito <- -Inf
valor.nan <- NaN
vetor.com.null <- c(10,10,10,NULL)
vetor.com.null

[1] 10 10 10

Operações aritméticas

No R é possível fazer operações aritméticas entre os valores disponíveis, abaixo teremos exemplos para algumas operações aritméticas simples:

# Adição
adicao <- 5+5
adicao

# Subtração
subtracao <- 5-5
subtracao

# Multiplicação
multiplicao <- 5*5
multiplicao

# Divisão
divisao <- 5/5
divisao

#Raiz Quadrada

raiz <- sqrt(10)
raiz

#Numero imaginário
numero <- 1i
numero

Operações com vetores

As operações aritméticas se estendem a vetores também, veja abaixo um exemplo:

# Vetor de dez posições
vetor <- c(1:10)

vetor * 2

# Veja que obtemos o dobro de cada valor do vetor, isso se aplica para todas as operações.

Tipos avançados

Fatores

Através de fatores, é possível classificar dados para que as máquinas consigam processar com mais facilidade. Veja que no output, o R escreve “Levels: Feminino Masculino” para identificar as classes encontradas.

sexo <- c("Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino")
fatorado <- as.factor(sexo);
fatorado

 [1] Feminino  Masculino Feminino  Masculino Feminino  Masculino Feminino  Masculino
 [9] Feminino  Masculino
Levels: Feminino Masculino

Listas

No R, temos o tipo de lista onde é possível armazenar vetores com tipos diferentes:

v1 <- c(1, 2, 3);
v2 <- c(T, F, T);
v3 <- c("a", "b", "c");
lista <- list(v1, v2, v3)

class(lista)

lista

Matrizes

Matrizes são um conjunto de valores distribuídos em linhas e colunas. A visualização abaixo deve esclarecer melhor:

matriz <- matrix(ncol = 5, nrow = 5, data = 1:5)

matriz

Você deve ter percebido que também é possível atribuir uma matriz para uma variável com esse exemplo.

Vamos a um exemplo de operação com matrizes

matrizA <- matrix(ncol = 5, nrow = 5, data = 1:5)
matrizB <- matrix(ncol = 5, nrow = 5, data = 1:5)
# Esta operação abaixo não é uma multiplicação de matrizes, é apenas uma multiplicação de valores.
matriz <- matrizA * matrizB
matriz

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    1    1    1    1
[2,]    4    4    4    4    4
[3,]    9    9    9    9    9
[4,]   16   16   16   16   16
[5,]   25   25   25   25   25

Para fazermos uma multiplicaçáo de matrizes, precisamos seguir uma regra: a quantidade de colunas da matriz A deve ser equivalente a quantidade de linhas da matriz B.

Abaixo um exemplo de multiplicação de matrizes:

linhas <- 5
colunas <- 10
matrizA <- matrix(ncol = linhas, nrow = colunas, data = 1:2)
matrizB <- matrix(ncol = colunas, nrow = linhas, data = 1:2)
matrizA %*% matrizB

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]    7    8    7    8    7    8    7    8    7     8
 [2,]   14   16   14   16   14   16   14   16   14    16
 [3,]    7    8    7    8    7    8    7    8    7     8
 [4,]   14   16   14   16   14   16   14   16   14    16
 [5,]    7    8    7    8    7    8    7    8    7     8
 [6,]   14   16   14   16   14   16   14   16   14    16
 [7,]    7    8    7    8    7    8    7    8    7     8
 [8,]   14   16   14   16   14   16   14   16   14    16
 [9,]    7    8    7    8    7    8    7    8    7     8
[10,]   14   16   14   16   14   16   14   16   14    16

Funções úteis para matrizes

matrizA <- matrix(ncol = 2, nrow = 2, data = 1:4)
print("Dimensões da matriz - Linhas x Colunas")

[1] "Dimensões da matriz - Linhas x Colunas"

dim(matrizA)  #inversa, esta deve ser quadrada

[1] 2 2

print("Transposta")

[1] "Transposta"

t(matrizA) #transposta

     [,1] [,2]
[1,]    1    2
[2,]    3    4

print("Identidade")

[1] "Identidade"

diag(matrizA) #identidade

[1] 1 4

print("Inversa")

[1] "Inversa"

solve(matrizA)  #inversa, esta deve ser quadrada

     [,1] [,2]
[1,]   -2  1.5
[2,]    1 -0.5

matrizA <- cbind(matrizA, c(5,2)) #Adiciona colunas no fim da matriz
#Colunas adicionadas
print("Colunas adicionadas")

[1] "Colunas adicionadas"

matrizA

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    2

print("Linhas adicionadas")

[1] "Linhas adicionadas"

matrizA <- rbind(matrizA, c(5,2, 3))
matrizA

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    2
[3,]    5    2    3

Data Frame

Criar um dataframe é bem simples, veja:

vetorA <- c(1,5,4,7)
vetorB <- c("Olá mundo")
dataframe <- data.frame(vetorA, vetorB)
# Colocando nomes nas colunas
colnames(dataframe) <- c("Numérico", "Texto")
dataframe

O mais legal do dataframe, é que conseguimos colocar dados heterogêneos, ao contrário dos vetores e matrizes.

Também é possível criar um dataframe a partir de uma lista:

lista <- list(c(1,2), c(T,F), c("teste", "teste2"))
dataframe <- data.frame(lista)
dataframe

Datas

Geralmente o trabalho com datas é uma das coisas mais complexas em programação. Vamos ver aqui algumas funções que o R disponibiliza para nós:

data.texto = "13/11/2018 T 19:10:00"
data.date = as.Date(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time1 = as.POSIXct(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time2 = as.POSIXlt(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time1

[1] "2018-11-13 19:10:00 -02"

data.time2

[1] "2018-11-13 19:10:00 -02"

data.date 

[1] "2018-11-13"

Através do método unclass, podemos ver o conteúdo real de uma variável, suas propriedades e etc. Quando passamos data.date para a função unclass, obtemos a quantidade de dias desde 01/01/1970 até a data da variável.

unclass(data.date)

[1] 17848

No caso de time1 e time2 veja que não temos diferenças no texto, entretanto veja quando fazemos o unclass.

print("Time1")

[1] "Time1"

unclass(data.time1)

[1] 1542143400
attr(,"tzone")
[1] "America/Sao_Paulo"

print("Time2")

[1] "Time2"

unclass(data.time2)

$`sec`
[1] 0

$min
[1] 10

$hour
[1] 19

$mday
[1] 13

$mon
[1] 10

$year
[1] 118

$wday
[1] 2

$yday
[1] 316

$isdst
[1] 1

$zone
[1] "-02"

$gmtoff
[1] NA

attr(,"tzone")
[1] "America/Sao_Paulo"

O unclass no time1 retorna a contagem em segundos desde 01/01/1970 até a data da variável!!

Para obter a data atual

Sys.Date()

[1] "2018-12-01"

Lubridate

Lubridate é um pacote disponibilizado para manipular datas no R. Para instalar e carregar:

install.packages("lubridate")

Installing package into <U+393C><U+3E31>C:/Users/sergio.prates/Documents/R/win-library/3.5<U+393C><U+3E32>
(as <U+393C><U+3E31>lib<U+393C><U+3E32> is unspecified)
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/lubridate_1.7.4.zip'
Content type 'application/zip' length 1568280 bytes (1.5 MB)
downloaded 1.5 MB

package ‘lubridate’ successfully unpacked and MD5 sums checked

The downloaded binary packages are in
    C:\Users\sergio.prates\AppData\Local\Temp\RtmpgpS10z\downloaded_packages

library(lubridate)

Attaching package: <U+393C><U+3E31>lubridate<U+393C><U+3E32>

The following object is masked from <U+393C><U+3E31>package:base<U+393C><U+3E32>:

    date

O lubridate fornece funções que retornarão a data no formato solicitado e além disso ele trabalha com o conceito de duração.

segundos  = dseconds(260)
minutos  = dminutes(260)
anos  = dyears(260)
duration(10, units = "seconds")

[1] "10s"

segundos

[1] "260s (~4.33 minutes)"

minutos

[1] "15600s (~4.33 hours)"

anos

[1] "8199360000s (~259.82 years)"

#abaixo as funções de data
#Ano mes dia
data <- ymd("20190101")
# Dia mes ano hora
dmy_h("1110201810")

[1] "2018-10-11 10:00:00 UTC"

# Retorna o dia da semana
wday(data, label = T)

[1] Tue
Levels: Sun < Mon < Tue < Wed < Thu < Fri < Sat

Estruturas de controle

Para tomar algumas decisões durante a execução de código, o R fornece algumas estruturas de controle.

souBonito <- TRUE
if (souBonito) {
  print("Eu Sei")
} else {
  print("Vish")
}

[1] "Eu Sei"

souBonito <- F
ifelse(souBonito, "verdade", "falso")

[1] "falso"

Estruturas de controle são muito úteis quando você precisa testar algum tipo de condição, se alguma compra foi realizada por exemplo, ou se algo ocorreu.

Estruturas de repetição = loops

Loops são utilizados quando precisamos por exemplo repetir um conjunto de instruções para determinados itens.

itens <- c(10,20,30)
for (variable in itens) {
  print(variable)
}

[1] 10
[1] 20
[1] 30

Veja que escrevemos todos os itens do vetor na tela, podemos utilizar para consolidar informações e enfim, para qualquer conjunto de instruções que precise se repetir.

Vamos montar um dataframe com um loop

vetor <- 1:10
acumulado <- 0
tabela <- data.frame();
for (variable in vetor) {
  acumulado <- variable + acumulado
   tabela <- rbind(tabela, c(variable, acumulado))
}
colnames(tabela) <- c("Valor1", "Acumulado")
tabela

Funções

Funções são utilizadas quando queremos reaproveitar algum trecho de código específico. por exemplo, digamos que precisamos calcular o enesimo termo de uma Progressão Aritmética

primeiro.termo <- 1
razao<- 2
obter.termo.pa <- function(primeiro.termo, numero.termo, razao) {
  return(primeiro.termo + (numero.termo - 1) * razao)
}
obter.termo.pa(primeiro.termo, 50, razao)

[1] 99

Em funções, podemos receber reticências como parametro, que significa que podemos receber N parametros na função. Um exemplo de função assim é a função paste.

concatena <- function(...) {
  c <- paste(...)
  c
}
concatena("Sergio", "Prates")

[1] "Sergio Prates"

Amostras

No R possuimos a função sample para randomizar a ocorrência de determinados valores

# Letras de a até g
amostra1 <- letters[1:7]
# Letras de A até D
amostra2 <- LETTERS[1:4]
# Pode repetir as ocorrências
sample(x = amostra1, size = 20, replace = T)

 [1] "a" "d" "f" "a" "e" "a" "g" "d" "d" "e" "e" "b" "d" "g" "a" "a" "d" "e" "c" "c"

# Não pode repetir as ocorrências
sample(x = amostra2, size = 3,  replace = F)

[1] "C" "D" "A"

Para garantir que sempre o mesmo resultado aconteça, podemos utilizar a função set.seed com um valor fixo

set.seed(1)
sample(x = amostra1, size = 20, replace = T)

 [1] "b" "c" "e" "g" "b" "g" "g" "e" "e" "a" "b" "b" "e" "c" "f" "d" "f" "g" "c" "f"

Simulações

O R nos fornecea alguns comandos para gerar dados aleatórios, sendo eles da família normal, binomial e uniforme.

Os comandos da familia normal possuem norm no final, os binomiais possuem binom e assim por diante… Veja abaixo exemplos:

set.seed(18) #garantindo que sempre sairá o mesmo resultado
# sd representa o desvio padrão dos dados
print("rnorm")

[1] "rnorm"

rnorm(n=10, mean=0, sd=1)

 [1]  0.92645924  1.82282117 -1.61056690 -0.28510975 -0.34207303  0.36617615
 [7] -1.32704085  2.41259221  0.06381535  1.54551478

print("dnorm")

[1] "dnorm"

dnorm(x = 1:10, mean = 0, sd = 1)

 [1] 2.419707e-01 5.399097e-02 4.431848e-03 1.338302e-04 1.486720e-06 6.075883e-09
 [7] 9.134720e-12 5.052271e-15 1.027977e-18 7.694599e-23

print("pnorm")

[1] "pnorm"

pnorm( q = 1:10, mean = 0, sd = 1)

 [1] 0.8413447 0.9772499 0.9986501 0.9999683 0.9999997 1.0000000 1.0000000 1.0000000
 [9] 1.0000000 1.0000000

print("rbinom")

[1] "rbinom"

rbinom(size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1), n = 10)

 [1]  0  0  1  1  0  1  7  8  9 10

print("dbinom")

[1] "dbinom"

dbinom(size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1), x = 1:10)

 [1] 1e-01 1e-02 1e-03 1e-04 1e-05 1e-06 1e+00 1e+00 1e+00 1e+00

print("pbinom")

[1] "pbinom"

pbinom(q = 1:10, size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1))

 [1] 1 1 1 1 1 1 1 1 1 1

print("Distribuição de poison")

[1] "Distribuição de poison"

rpois(100, 5)

  [1]  5  5  3  4  8  5  3  3  3  6  8  5  6  5  2  2  7  1  3  5  3  3  6  6  1  4  3
 [28]  7  5  5  4  2  1  3  3  6  5 12  6  7  8  4  2 10  7  4  6  5  2  3  6  5  7  5
 [55]  6  6 11  5  6  7  7  4  5  3  6  6  7  4  2  6  4  6  4  6  3  4  3  7  6 13  4
 [82]  3  5  3  1  4  3  5  8  8  5  6  6  6  3  6  5  3  2  1

Plots básico

Para fazer plots, ou gráficos em R podemos utilizar a função plot()

plot(x = cars$speed, y = cars$dist, type = "p", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

plot(x = cars$speed, y = cars$dist, type = "l", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

plot(x = cars$speed, y = cars$dist, type = "h", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

Usando outra biblioteca…

Podemos utilizar a equação abaixo para plotar um gráfico linear \(y = \beta_0 + \beta_1 + \epsilon\)

Onde

\(\beta_0 = 0,5\)

\(\beta_1 = 2,0\)

\(x\sim N(0;1²)\)

\(\epsilon\sim N(0;2²)\)

#install.packages('plotly')
library(plotly)
set.seed(5)
x = rnorm(n=350, mean=0, sd=1)
e = rnorm(n=350, mean=0, sd=2)
y=0.5 + 2*x + e
plot(x=x, y=y)

plot_ly(x=x, y=y, type="scatter", mode="markers")

Baixando dados externos

Com a função download file podemos baixar arquivos da web, neste caso ele sempre trata como texto os dados.

baixar <- function(url) {
  
  #Cria a pasta caso não exista
  
  if(!file.exists('data')){
    dir.create('data')
  }
  
  file.url = url
  file.local = file.path('./data', basename(file.url))
  download.file(url = file.url, destfile = file.local , mode='wb')
}

baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas.csv')
baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Partidas.csv')
baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Jogadores.csv')
baixar('https://github.com/elthonf/fiap-mba-r/raw/master/data/cameras.baltimore.xlsx')

Lendo dados de csv’s

Para ler dados de csvs podemos utilizar a função read.csv

copas <- read.csv('./data/Copas.csv', header = T)
copas

Para ler dados do excel, podemos utilizar o pacote

install.packages('readxl')

Installing package into <U+393C><U+3E31>C:/Users/sergio.prates/Documents/R/win-library/3.5<U+393C><U+3E32>
(as <U+393C><U+3E31>lib<U+393C><U+3E32> is unspecified)
also installing the dependencies <U+393C><U+3E31>rematch<U+393C><U+3E32>, <U+393C><U+3E31>cellranger<U+393C><U+3E32>

trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/rematch_1.0.1.zip'
Content type 'application/zip' length 15994 bytes (15 KB)
downloaded 15 KB

trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/cellranger_1.1.0.zip'
Content type 'application/zip' length 103141 bytes (100 KB)
downloaded 100 KB

trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/readxl_1.1.0.zip'
Content type 'application/zip' length 1499856 bytes (1.4 MB)
downloaded 1.4 MB

package ‘rematch’ successfully unpacked and MD5 sums checked
package ‘cellranger’ successfully unpacked and MD5 sums checked
package ‘readxl’ successfully unpacked and MD5 sums checked

The downloaded binary packages are in
    C:\Users\sergio.prates\AppData\Local\Temp\RtmpOqvMmO\downloaded_packages

library(readxl)

Manipulando estruturas de tabelas com dplyr

O pacote dplyr nos ajuda a manipular estruturas de tabelas de maneira bastante eficiente.

Abaixo utilizamos o pipe para passar o conteúdo

install.packages('dplyr')

Error in install.packages : Updating loaded packages

library(dplyr)

Attaching package: <U+393C><U+3E31>dplyr<U+393C><U+3E32>

The following objects are masked from <U+393C><U+3E31>package:stats<U+393C><U+3E32>:

    filter, lag

The following objects are masked from <U+393C><U+3E31>package:base<U+393C><U+3E32>:

    intersect, setdiff, setequal, union